// 购买足量干草的最小花费
// 有n个提供干草的公司，每个公司都有两个信息
// cost[i]代表购买1次产品需要花的钱
// val[i]代表购买1次产品所获得的干草数量
// 每个公司的产品都可以购买任意次
// 你一定要至少购买h数量的干草，返回最少要花多少钱
// 测试链接 : https://www.luogu.com.cn/problem/P2918
// 提交以下的所有代码，可以直接通过

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 101;
const int MAXM = 55001;
int cost[MAXN];
int val[MAXN];
int dp[MAXM];
int n, h, maxv, m;
// 0x3f3f3f3f 是 INT_MAX 的一半，
// 使用它的好处是足够大且不会溢出
const int INF = 0x3f3f3f3f;

// dp[i][j] : 1...i里挑公司，购买严格j磅干草，需要的最少花费
// 1) dp[i-1][j]
// 2) dp[i][j-val[i]] + cost[i]
// 两种可能性中选最小
// 但是关于j需要进行一定的扩充，原因视频里讲了
int compute1()
{
    vector<vector<int>> dp(n + 1, vector<int>(m + 1, INT_MAX));
    dp[0][0] = 0;
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 0; j <= m; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j - val[i] >= 0 && dp[i][j - val[i]] != INT_MAX)
            {
                dp[i][j] = min(dp[i][j], dp[i][j - val[i]] + cost[i]);
            }
        }
    }
    
    int ans = INT_MAX;
    // >= h
    // h h+1 h+2 ... m
    for(int j = h; j <= m; ++j) ans = min(ans, dp[n][j]);
    return ans;
}

// 空间压缩
int compute2()
{
    vector<int> dp(m + 1, INT_MAX);
    dp[0] = 0;
    for(int i = 1; i <= n; ++i)
    {
        for(int j = val[i]; j <= m; ++j)
        {
            if(dp[j - val[i]] != INT_MAX)
            {
                dp[j] = min(dp[j], dp[j - val[i]] + cost[i]);
            }
        }
    }
    int ans = *min_element(dp.begin() + h, dp.begin() + m + 1);
    return ans;
}

int compute3()
{
    int dp[n + 1][m + 1];
    memset(dp, 0x3f, sizeof dp);
    dp[0][0] = 0;
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 0; j <= m; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j - val[i] >= 0)
            {
                // 如果 dp[i][j - val[i]] 和 dp[i][j] 都等于 
                // INF 的话，那么取最小值后，dp[i][j] 还是 INF 
                // 这样也就表明无法刚好凑出 j 磅干草
                dp[i][j] = min(dp[i][j], dp[i][j - val[i]] + cost[i]);
            }
        }
    }
    
    int ans = INF;
    // >= h
    // h h+1 h+2 ... m
    for(int j = h; j <= m; ++j) ans = min(ans, dp[n][j]);
    return ans;
}

// 空间压缩
int compute4()
{
    memset(dp, 0x3f, sizeof dp);
    dp[0] = 0;
    for(int i = 1; i <= n; ++i)
    {
        for(int j = val[i]; j <= m; ++j)
        {
            dp[j] = min(dp[j], dp[j - val[i]] + cost[i]);
        }
    }
    int ans = *min_element(dp + h, dp + m + 1);
    return ans;
}

int main()
{
    scanf("%d%d", &n, &h);
    for(int i = 1; i <= n; ++i)
    {
        scanf("%d%d", &val[i], &cost[i]);
        maxv = max(maxv, val[i]);
    }
    m = h + maxv;
    printf("%d\n", compute4());

    return 0;
}